package com.trs.zk.modules.sys.service;

import com.trs.zk.common.config.Global;
import com.trs.zk.common.entity.Page;
import com.trs.zk.common.service.BaseService;
import com.trs.zk.common.shiro.Digests;
import com.trs.zk.common.shiro.Encodes;
import com.trs.zk.modules.sys.dao.UserDao;
import com.trs.zk.modules.sys.entity.User;
import com.trs.zk.modules.sys.util.UserUtils;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Isolation;
import org.springframework.transaction.annotation.Transactional;

import java.util.Date;
import java.util.List;

/**
 * 系统管理，安全相关实体的管理类,包括用户、角色、菜单.
 */
@Service
@Transactional(readOnly = true)
public class SystemService extends BaseService implements InitializingBean {

    public static final String HASH_ALGORITHM = "SHA-1";
    public static final int HASH_INTERATIONS = 1024;
    public static final int SALT_SIZE = 8;

    @Autowired
    private UserDao IUserDao;

    /**
     * 获取用户
     *
     * @param id
     * @return
     */
    public User getUser(int id) {
        return UserUtils.get(id);
    }

    /**
     * 根据登录名获取用户
     *
     * @param loginName
     * @return
     */
    public User getUserByLoginName(String loginName) {
        return UserUtils.getByLoginName(loginName);
    }

    /**
     * 添加用户与用户组的关系
     * @param groupIds
     * @param id
     * @return
     */
    @Transactional(rollbackFor = Exception.class,isolation = Isolation.READ_COMMITTED)
    public int addUserForGroup(String [] groupIds, Integer id){
        return IUserDao.addUserForGroup(groupIds, id);
    }

    /**
     * 根据登录名获取用户
     * status为0的
     * @param loginName
     * @return
     */
    public User getUserByLoginNameWechat(String loginName) {
        return UserUtils.getByLoginNameWechat(loginName);
    }


    public Page<User> findUser(Page<User> page, User user) {
        // 生成数据权限过滤条件（dsf为dataScopeFilter的简写，在xml中使用 ${sqlMap.dsf}调用权限SQL）
        //user.getSqlMap().put("dsf", dataScopeFilter(user.getCurrentUser(), "o", "a"));
        // 设置分页参数
        user.setPage(page);
        // 执行分页查询
        page.setList(IUserDao.findList(user));
        return page;
    }


    /**
     * 无分页查询人员列表
     *
     * @param user
     * @return
     */
    public List<User> findUser(User user) {
        // 生成数据权限过滤条件（dsf为dataScopeFilter的简写，在xml中使用 ${sqlMap.dsf}调用权限SQL）
        //user.getSqlMap().put("dsf", dataScopeFilter(user.getCurrentUser(), "o", "a"));
        List<User> list = IUserDao.findList(user);
        return list;
    }

    //add by guo_jj 禁用
    @Transactional(rollbackFor = Exception.class,isolation = Isolation.READ_COMMITTED)
    public int disableById(String id) {
        return IUserDao.disableById(id);
    }

    /**
     * 
    * saveUser
    * @描述: 
    *
    * @param user
    * @return
    * @异常:
    * @修改人：
    * @修改日期：
    * @备注：
     */
    @Transactional(readOnly = false)
    public boolean saveUser(User user) {
    	boolean flag=false;
        if (user.getId() == 0) {        	
            user.preInsert();
            IUserDao.insert(user);
            flag=true;
        } else {
            // 清除原用户机构用户缓存
            User oldUser = IUserDao.get(user.getId());
            UserUtils.clearCache(oldUser);
            // 更新用户数据
            user.preUpdate();
            IUserDao.update(user);
            flag=true;
        }
        // 更新用户与角色关联
       // IUserDao.deleteUserRole(user);
        /* if (user.getRoleList() != null && user.getRoleList().size() > 0) {
        	IUserDao.insertUserRole(user);
        }else {
                throw new ServiceException(user.getLoginName() + "没有设置角色！");
            }*/
        
        // 清除用户缓存
//			// 清除权限缓存
//			systemRealm.clearAllCachedAuthorizationInfo();
        UserUtils.clearCache(user);
		return flag;
    }

    @Transactional(readOnly = false)
    public void updateUserInfo(User user) {
        user.preUpdate();
        IUserDao.updateUserInfo(user);
        // 清除用户缓存
        UserUtils.clearCache(user);
//		// 清除权限缓存
//		systemRealm.clearAllCachedAuthorizationInfo();
    }

    @Transactional(readOnly = false)
    public int deleteUser(User user) {
        int ret= IUserDao.delete(user);

        // 清除用户缓存
        UserUtils.clearCache(user);
//		// 清除权限缓存
//		systemRealm.clearAllCachedAuthorizationInfo();
		return ret;
    }

    @Transactional(rollbackFor = Exception.class,isolation = Isolation.READ_COMMITTED)
    public int deleteUserByIds(String ids) {
        return IUserDao.deleteByIds(ids);
    }

    /**
     * @param id 用户ID
     * @return
     *方法描述 个人中心--获取招商所在地
     */
    public User getInvestment(int id){
        return IUserDao.getInvestment(id);
    }

    @Transactional(readOnly = false)
    public void updatePasswordById(int id, String userName, String newPassword) {
        User user = new User(id);
        user.setPassword(entryptPassword(newPassword));
        IUserDao.updatePasswordById(user);
        // 清除用户缓存
        user.setUsername(userName);
        UserUtils.clearCache(user);
//		// 清除权限缓存
//		systemRealm.clearAllCachedAuthorizationInfo();
    }

    @Transactional(readOnly = false)
    public void updateUserLoginInfo(User user) {
        // 保存上次登录信息
        user.setLastlogintime(new Date());
        IUserDao.updateLoginInfo(user);
    }

    @Transactional(readOnly = false)
    public int updateStatusById(User user){
        return  IUserDao.updateStatusById(user);
    }

    /**
     * 生成安全的密码，生成随机的16位salt并经过1024次 sha-1 hash
     */
    public static String entryptPassword(String plainPassword) {
        String plain = Encodes.unescapeHtml(plainPassword);
        byte[] salt = Digests.generateSalt(SALT_SIZE);
        byte[] hashPassword = Digests.sha1(plain.getBytes(), salt, HASH_INTERATIONS);
        return Encodes.encodeHex(salt) + Encodes.encodeHex(hashPassword);
    }

    public static void main(String[] args) {
        System.out.println(entryptPassword("123456"));
    }

    /**
     * 验证密码
     *
     * @param plainPassword 明文密码
     * @param password      密文密码
     * @return 验证成功返回true
     */
    public static boolean validatePassword(String plainPassword, String password) {
        String plain = Encodes.unescapeHtml(plainPassword);
        byte[] salt = Encodes.decodeHex(password.substring(0, 16));
        byte[] hashPassword = Digests.sha1(plain.getBytes(), salt, HASH_INTERATIONS);
        return password.equals(Encodes.encodeHex(salt) + Encodes.encodeHex(hashPassword));
    }
    /**
     * 
    * validateLoginNameAndPassword
    * @描述:判断是否登录成功 
    *
    * @return
    * @异常:
    * @修改人：
    * @修改日期：
    * @备注：
     */
    public static User validateLoginNameAndPassword(User u){
    	User user=new SystemService().getUserByLoginName(u.getUsername());
    	if (user!=null) {
    		boolean flag=validatePassword(u.getPassword(),user.getPassword());
    		if(flag){
    		return user;
    		}else{
    		return null;	
    		}
		}else{
			return null;
		}
    	
    }

    /**
     * 获取Key加载信息
     */
    public static boolean printKeyLoadMessage() {
        StringBuilder sb = new StringBuilder();
        sb.append("\r\n======================================================================\r\n");
        sb.append("\r\n    欢迎使用 " + Global.getConfig("productName") + "  - Powered By \r\n");
        sb.append("\r\n======================================================================\r\n");
        System.out.println(sb.toString());
        return true;
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        // TODO Auto-generated method stub

    }

    @Transactional(readOnly = false)
    public boolean saveUserWeChat(User user) {
        boolean flag=false;
        if (user.getId() == 0) {
            user.preInsert();
            IUserDao.insertWeChat(user);
            flag=true;
        } else {
            // 清除原用户机构用户缓存
            User oldUser = IUserDao.get(user.getId());
            UserUtils.clearCache(oldUser);
            // 更新用户数据
            user.preUpdate();
            IUserDao.update(user);
            flag=true;
        }

        // 清除用户缓存
        UserUtils.clearCache(user);
        return flag;
    }

    public User getUserByWechat(String wechat) {
        return IUserDao.getUserByWechat(wechat);
    }

    public User getUserByUnionId(String unionId) {
        return IUserDao.getUserByUnionId(unionId);
    }

    @Transactional(readOnly = false)
    public int deleteUserById(int id) {
        return IUserDao.deleteById(id);
    }
}
